/***************************************************************************
fps.c  -  description
-------------------
begin                : Sun Oct 28 2001
copyright            : (C) 2001 by Pete Bernert
email                : BlackDove@addcom.de
***************************************************************************/
/***************************************************************************
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version. See also the license.txt file for *
*   additional informations.                                              *
*                                                                         *
***************************************************************************/

#define _IN_FPS

#include "externals.h"
#include "fps.h"
#include "gpu.h"

#ifdef _XBOX
#include <xtl.h>
#endif
// FPS stuff
float          fFrameRateHz=0;
DWORD          dwFrameRateTicks=16;
float          fFrameRate;
int            iFrameLimit;
int            UseFrameLimit=0;
int            UseFrameSkip=0;

// FPS skipping / limit
BOOL   bInitCap = TRUE;
float  fps_skip = 0;
float  fps_cur  = 0;

#define MAXLACE 16

void CheckFrameRate(void)
{
	if(UseFrameSkip)                                      // skipping mode?
	{
		if(!(dwActFixes&0x80))                              // not old skipping mode?
		{
			dwLaceCnt++;                                      // -> store cnt of vsync between frames
			if(dwLaceCnt>=MAXLACE && UseFrameLimit)           // -> if there are many laces without screen toggling,
			{                                                //    do std frame limitation
				if(dwLaceCnt==MAXLACE) bInitCap=TRUE;
				FrameCap();
			}
		}
		else if(UseFrameLimit) FrameCap();
		calcfps();                                          // -> calc fps display in skipping mode
	}
	else                                                  // non-skipping mode:
	{
		if(UseFrameLimit) FrameCap();                       // -> do it
		if(ulKeybits&KEY_SHOWFPS) calcfps();                // -> and calc fps display
	}
}

#define TIMEBASE 100000

unsigned long timeGetTime()
{
	struct timeval tv;
	gettimeofday(&tv, 0);                                 // well, maybe there are better ways
	return tv.tv_sec * 100000 + tv.tv_usec/10;            // to do that, but at least it works
}

void FrameCap (void)
{
	static unsigned long curticks, lastticks, _ticks_since_last_update;
	static unsigned int TicksToWait = 0;
	int overslept=0, tickstogo=0;
	BOOL Waiting = TRUE;

	{
		curticks = timeGetTime();
		_ticks_since_last_update = curticks - lastticks;

		if((_ticks_since_last_update > TicksToWait) ||
			(curticks <lastticks))
		{
			lastticks = curticks;
			overslept = _ticks_since_last_update - TicksToWait;
			if((_ticks_since_last_update-TicksToWait) > dwFrameRateTicks)
				TicksToWait=0;
			else
				TicksToWait=dwFrameRateTicks - overslept;
		}
		else
		{
			while (Waiting)
			{
				curticks = timeGetTime();
				_ticks_since_last_update = curticks - lastticks;
				tickstogo = TicksToWait - _ticks_since_last_update;
				if ((_ticks_since_last_update > TicksToWait) ||
					(curticks < lastticks) || tickstogo < overslept)
				{
					Waiting = FALSE;
					lastticks = curticks;
					overslept = _ticks_since_last_update - TicksToWait;
					TicksToWait = dwFrameRateTicks - overslept;
					return;
				}
				if (tickstogo >= 200 && !(dwActFixes&16))
					usleep(tickstogo*10 - 200);
			}
		}
	}
}

#define MAXSKIP 120

void FrameSkip(void)
{
	static int   iNumSkips=0,iAdditionalSkip=0;           // number of additional frames to skip
	static DWORD dwLastLace=0;                            // helper var for frame limitation
	static DWORD curticks, lastticks, _ticks_since_last_update;
	int tickstogo=0;
	static int overslept=0;

	if(!dwLaceCnt) return;                                // important: if no updatelace happened, we ignore it completely

	if(iNumSkips)                                         // we are in skipping mode?
	{
		dwLastLace+=dwLaceCnt;                              // -> calc frame limit helper (number of laces)
		bSkipNextFrame = TRUE;                              // -> we skip next frame
		iNumSkips--;                                        // -> ok, one done
	}
	else                                                  // ok, no additional skipping has to be done...
	{                                                    // we check now, if some limitation is needed, or a new skipping has to get started
		DWORD dwWaitTime;

		if(bInitCap || bSkipNextFrame)                      // first time or we skipped before?
		{
			if(UseFrameLimit && !bInitCap)                    // frame limit wanted and not first time called?
			{
				DWORD dwT=_ticks_since_last_update;             // -> that's the time of the last drawn frame
				dwLastLace+=dwLaceCnt;                          // -> and that's the number of updatelace since the start of the last drawn frame

				curticks = timeGetTime();                       // -> now we calc the time of the last drawn frame + the time we spent skipping
				_ticks_since_last_update= dwT+curticks - lastticks;

				dwWaitTime=dwLastLace*dwFrameRateTicks;         // -> and now we calc the time the real psx would have needed

				if(_ticks_since_last_update<dwWaitTime)         // -> we were too fast?
				{
					if((dwWaitTime-_ticks_since_last_update)>     // -> some more security, to prevent
						(60*dwFrameRateTicks))                     //    wrong waiting times
						_ticks_since_last_update=dwWaitTime;

					while(_ticks_since_last_update<dwWaitTime)    // -> loop until we have reached the real psx time
					{                                            //    (that's the additional limitation, yup)
						curticks = timeGetTime();
						_ticks_since_last_update = dwT+curticks - lastticks;
					}
				}
				else                                            // we were still too slow ?!!?
				{
					if(iAdditionalSkip<MAXSKIP)                   // -> well, somewhen we really have to stop skipping on very slow systems
					{
						iAdditionalSkip++;                          // -> inc our watchdog var
						dwLaceCnt=0;                                // -> reset lace count
						lastticks = timeGetTime();
						return;                                     // -> done, we will skip next frame to get more speed
					} 
				}
			}

			bInitCap=FALSE;                                   // -> ok, we have inited the frameskip func
			iAdditionalSkip=0;                                // -> init additional skip
			bSkipNextFrame=FALSE;                             // -> we don't skip the next frame
			lastticks = timeGetTime();                        // -> we store the start time of the next frame
			dwLaceCnt=0;                                      // -> and we start to count the laces 
			dwLastLace=0;
			_ticks_since_last_update=0;
			return;                                           // -> done, the next frame will get drawn
		}

		bSkipNextFrame=FALSE;                               // init the frame skip signal to 'no skipping' first

		curticks = timeGetTime();                           // get the current time (we are now at the end of one drawn frame)
		_ticks_since_last_update = curticks - lastticks;

		dwLastLace=dwLaceCnt;                               // store curr count (frame limitation helper)
		dwWaitTime=dwLaceCnt*dwFrameRateTicks;              // calc the 'real psx lace time'
		if (dwWaitTime >= overslept)
			dwWaitTime-=overslept;

		if(_ticks_since_last_update>dwWaitTime)             // hey, we needed way too long for that frame...
		{
			if(UseFrameLimit)                                 // if limitation, we skip just next frame,
			{                                                // and decide after, if we need to do more
				iNumSkips=0;
			}
			else
			{
				iNumSkips=_ticks_since_last_update/dwWaitTime;  // -> calc number of frames to skip to catch up
				iNumSkips--;                                    // -> since we already skip next frame, one down
				if(iNumSkips>MAXSKIP) iNumSkips=MAXSKIP;        // -> well, somewhere we have to draw a line
			}
			bSkipNextFrame = TRUE;                            // -> signal for skipping the next frame
		}
		else                                                // we were faster than real psx? fine :)
			if(UseFrameLimit)                                   // frame limit used? so we wait til the 'real psx time' has been reached
			{
				if(dwLaceCnt>MAXLACE)                             // -> security check
					_ticks_since_last_update=dwWaitTime;

				while(_ticks_since_last_update<dwWaitTime)        // -> just do a waiting loop...
				{
					curticks = timeGetTime();
					_ticks_since_last_update = curticks - lastticks;

					tickstogo = dwWaitTime - _ticks_since_last_update;
					if (tickstogo-overslept >= 200 && !(dwActFixes&16))
						usleep(tickstogo*10 - 200);
				}
			}
			overslept = _ticks_since_last_update - dwWaitTime;
			if (overslept < 0)
				overslept = 0;
			lastticks = timeGetTime();                          // ok, start time of the next frame
	}

	dwLaceCnt=0;                                          // init lace counter
}

void calcfps(void)
{
	static unsigned long curticks,_ticks_since_last_update,lastticks;
	static long   fps_cnt = 0;
	static unsigned long  fps_tck = 1;
	static long          fpsskip_cnt = 0;
	static unsigned long fpsskip_tck = 1;

	{
		curticks = timeGetTime();
		_ticks_since_last_update=curticks-lastticks;

		if(UseFrameSkip && !UseFrameLimit && _ticks_since_last_update)
			fps_skip=min(fps_skip,((float)TIMEBASE/(float)_ticks_since_last_update+1.0f));

		lastticks = curticks;
	}

	if(UseFrameSkip && UseFrameLimit)
	{
		fpsskip_tck += _ticks_since_last_update;

		if(++fpsskip_cnt==2)
		{
			fps_skip = (float)2000/(float)fpsskip_tck;
			fps_skip +=6.0f;
			fpsskip_cnt = 0;
			fpsskip_tck = 1;
		}
	}

	fps_tck += _ticks_since_last_update;

	if(++fps_cnt==20)
	{
		fps_cur = (float)(TIMEBASE*20)/(float)fps_tck;

		fps_cnt = 0;
		fps_tck = 1;

		//if(UseFrameLimit && fps_cur>fFrameRateHz)           // optical adjust ;) avoids flickering fps display
		//fps_cur=fFrameRateHz;
	}

}

void PCFrameCap (void)
{
	static unsigned long curticks, lastticks, _ticks_since_last_update;
	static unsigned long TicksToWait = 0;
	BOOL Waiting = TRUE;

	while (Waiting)
	{
		curticks = timeGetTime();
		_ticks_since_last_update = curticks - lastticks;
		if ((_ticks_since_last_update > TicksToWait) ||
			(curticks < lastticks))
		{
			Waiting = FALSE;
			lastticks = curticks;
			TicksToWait = (TIMEBASE/ (unsigned long)fFrameRateHz);
		}
	}
}

void PCcalcfps(void)
{
	static unsigned long curticks,_ticks_since_last_update,lastticks;
	static long  fps_cnt = 0;
	static float fps_acc = 0;
	float CurrentFPS=0;

	curticks = timeGetTime();
	_ticks_since_last_update=curticks-lastticks;
	if(_ticks_since_last_update)
		CurrentFPS=(float)TIMEBASE/(float)_ticks_since_last_update;
	else CurrentFPS = 0;
	lastticks = curticks;

	fps_acc += CurrentFPS;

	if(++fps_cnt==10)
	{
		fps_cur = fps_acc / 10;
		fps_acc = 0;
		fps_cnt = 0;
	}

	fps_skip=CurrentFPS+1.0f;
}

void SetAutoFrameCap(void)
{
	if(iFrameLimit==1)
	{
		fFrameRateHz = fFrameRate;
		dwFrameRateTicks=(TIMEBASE*100 / (unsigned long)(fFrameRateHz*100));
		return;
	}

	if(dwActFixes&32)
	{
		if (PSXDisplay.Interlaced)
			fFrameRateHz = PSXDisplay.PAL?50.0f:60.0f;
		else fFrameRateHz = PSXDisplay.PAL?25.0f:30.0f;
	}
	else
	{
		fFrameRateHz = PSXDisplay.PAL?50.0f:59.94f;
		dwFrameRateTicks=(TIMEBASE*100 / (unsigned long)(fFrameRateHz*100));
	}
}

void SetFPSHandler(void)
{
}

void InitFPS(void)
{
	if(!fFrameRate) fFrameRate=200.0f;
	if(fFrameRateHz==0) fFrameRateHz=fFrameRate;          // set user framerate
	dwFrameRateTicks=(TIMEBASE / (unsigned long)fFrameRateHz);
}
